package com.csj.mvvmtest

import com.csj.mvvm.ui.base.fromJson
import com.google.gson.Gson
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import kotlin.system.measureTimeMillis

object TestKtl {
    var innerSet: MutableCollection<String> = HashSet()
    val sset: MutableCollection<String> = CountingSet2(innerSet)

    @JvmStatic
    fun main(args: Array<String>) {
        val testStr = "abc"
        val sum = testStr.sumOf { it.code }
        println(sum)

//        var result = with(Person("RainyJiang", 100)) {
//            println(name + age)
//            1000
//        }
//        println(result)

        var result = Person("RainyJiang", 100).run {
            println(name + age)
            1000
        }
        println(result)

        val test = """{"age":1}""".trimIndent()
        val user: Person = Gson().fromJson(test)
        println(user.fullName)
        val str2 = """
            value1/n
            value2
            value3
            value4
            "value5"
""".trimMargin()//去除每行开头的空格
        println(str2)

        println("12eafsfsfdbzzsa".filter { it in 'a'..'f' })
    }

}

/**
* 函数作为参数，实现String类的字符过滤
* */
fun String.filter(predicate: (Char) -> Boolean): String {
    val sb = StringBuilder()
    for (index in 0 until length) {
        val element = get(index)
        if (predicate(element)) sb.append(element)
    }
    return sb.toString()
}

//public interface Collection<out E> : Iterable<E> {
//    public operator fun contains(element: @UnsafeVariance E): Boolean
//}

//不阻塞
suspend fun simple2(): List<Int> {
    delay(1000) // 假装我们在这里做了一些异步的事情
    return listOf(1, 2, 3)
}

//http://www.kotlincn.net/docs/reference/coroutines/flow.html
//Flow是冷流 :只有订阅者订阅时，才开始执行发射数据流的代码
fun simple(): Flow<Int> = flow { // 流构建器
    log("Flow started")
    for (i in 1..3) {
        delay(1000) // 假装我们在这里做了一些有用的事情
        emit(i) // 发送下一个值
    }
}

fun log(msg: String) = println("[${Thread.currentThread().name}] $msg")

fun simple3(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(1000) // 假装我们以消耗 CPU 的方式进行计算
        log("Emitting $i")
        emit(i) // 发射下一个值
    }
}.flowOn(Dispatchers.Default) // 在流构建器中改变消耗 CPU 代码上下文的正确方式

fun main() = runBlocking<Unit> {
//    simple2().forEach { value -> println(value) }
//    // 启动并发的协程以验证主线程并未阻塞
//    launch {
//        for (k in 1..3) {
//            println("I'm not blocked $k")
//            delay(1000)
//        }
//    }
//    println("Calling simple function...")
//    val flow = simple()
//    println("Calling collect...")
//    // 收集这个流
//    flow.collect { value -> println(value) }
//    println("Calling collect again...")
//    flow.collect { value -> println(value) }
//    // 将一个整数区间转化为流
//    (1..3).asFlow().collect { value -> println(value) }
//    withTimeoutOrNull(2500) { // 在 2500 毫秒后超时
//        simple().collect { value -> println(value) }
//    }
//    simple3().collect { value ->
//        log("Collected $value")
//    }
//    log("Done")
//    val time = measureTimeMillis {
//        simple()
////            .buffer() // 缓冲发射项，无需等待
////            .conflate() // 合并发射项，不对每个值进行处理
////            .collect { value ->
////                delay(3000) // 假装我们花费 300 毫秒来处理它
////                log(value.toString())
////            }
//            .collectLatest { value -> // 取消并重新发射最后一个值
//                println("Collecting $value")
//                delay(3000) // 假装我们花费 300 毫秒来处理它
//                println("Done $value")
//            }
//    }
//    log("Collected in $time ms")
    val nums = (1..3).asFlow() // 数字 1..3
    val strs = flowOf(1, "two", "three") // 字符串
    nums.zip(strs) { a, b -> "$a -> $b" } // 组合单个字符串
        .collect { println(it) } // 收集并打印

}


